home *** CD-ROM | disk | FTP | other *** search
/ BBS in a Box 3 / BBS in a box - Trilogy III.iso / Files / Prog / L-M / mini / VT100.c < prev    next >
Encoding:
C/C++ Source or Header  |  1987-09-29  |  27.2 KB  |  1,265 lines  |  [TEXT/MPS ]
  1. /*
  2.     Kermit Vt100 emulator code modified by Jerry LeVan
  3.     to fit the MiniTerm project.
  4.    Date Sept 7,1987
  5.    Changes:    Modified the cursor control routines
  6.                Added Control character Display
  7.             Added Line Drawing Graphics Support
  8. */
  9. /* By Frank on June 20 - Add parity to all outbound chars using software */
  10. /*  Also, ignore DEL (0177) characters on input. */
  11. /* By Bill on May 29 - Add Key set translation */
  12. /* By WBC3 on Apr 24 - Add ^^, ^@ and ^_.  Also use Pascal strings for */
  13. /*  output in the terminal emulator */
  14. /* By WBC3 on Apr 23 - Add query terminal and be more fastidious about */
  15. /*  ignoring sequences we don't know about */
  16. /* By WBC3 on Apr 22 - Fix tab stops to conform to the rest of the world! */
  17. /* By Bill on Apr 21 - Fix immediate echo problems. */
  18. /*  do less cursor_erase, cursor_draw stuff */
  19.  
  20. /*
  21.  * vt100.c
  22.  *
  23.  * Module of MiniTerm: contains most code for the terminal simulation
  24.  * routine.
  25.  */
  26.  
  27. #include <types.h>
  28. #include <Quickdraw.h>
  29. #include <Windows.h>
  30. #include <Fonts.h>
  31. #include <Menus.h>
  32. #include <Events.h>
  33. #include <serial.h>
  34. #include <OSUtils.h>
  35.  
  36. #define tickCount *(long *)0x16a
  37. #define caretTime *(long *)0x2f4
  38.  
  39. #define False         0
  40. #define True         1
  41. #define FALSE         0
  42. #define TRUE         1
  43. #define MAXLIN        24
  44. #define MAXCOL        80
  45. #define LINEHEIGHT  11
  46. #define CHARWIDTH    6
  47. #define TOPMARGIN    3                /* Terminal display constants */
  48. #define BOTTOMMARGIN (LINEHEIGHT * MAXLIN + TOPMARGIN)
  49. #define LEFTMARGIN   3
  50. #define RIGHTMARGIN  (CHARWIDTH * MAXCOL + LEFTMARGIN)
  51. #define LINEADJ         3            /* Amount of char below base line */
  52.  
  53. /* cursor variables */
  54. static char cursorActive;
  55. static Boolean cursorInverted=false ; /* true means inverted pen rect */
  56. static long cursorTime;
  57. static Rect penRect;
  58. static FontInfo fontstuff;
  59. Boolean useBlockCursor = false;
  60. Boolean blink=true;                /* true means blink the cursor */
  61. Boolean invisible = false;
  62.  
  63. /* output character handling */
  64.  
  65. unsigned char obuf[2] = {1,0};        /* single char output buffer */
  66.  
  67. /* Tab settings */
  68.  
  69. #define NUMTABS 9
  70.  
  71. short tabstops[NUMTABS] = {8,16,24,32,40,48,56,64,72};
  72.  
  73. int Invert=FALSE,            /* Flag for Inverted terminal mode */
  74.     insert=FALSE,
  75.     topmargin=TOPMARGIN,        /* Edges of adjustable window */
  76.     bottommargin=BOTTOMMARGIN,
  77.     textstyle=0,
  78.     autowrap=TRUE;            /* Autowrap on by default */
  79.  
  80. char *querystring="\033[?6c";        /* Answer we are a VT102 */
  81.  
  82. short scrollrect[] = { TOPMARGIN, LEFTMARGIN, BOTTOMMARGIN, RIGHTMARGIN };
  83.  
  84. RgnHandle dumptr;                /* Dummy ptr to satisfy scrollbits */
  85.  
  86. /* Screen book keeping variables */
  87.  
  88. char scr[MAXLIN][MAXCOL+1];        /* Characters on the screen */
  89. short nxtlin[MAXLIN], toplin, botlin;    /* Linked list of lines */
  90. int curlin, curcol, abslin;        /* Cursor position */
  91. int savcol, savlin;            /* Cursor save variables */
  92. int scrtop, scrbot;            /* Absolute scrolling region bounds */
  93.  
  94. /* Stuff for escape character processing */
  95.  
  96. #define CF_OUTC 0            /* Just output the char */
  97. #define CF_SESC    1            /* In a single char escape seq */
  98. #define CF_MESC    2            /* In a multi char '[' escape seq */
  99. #define CF_TOSS    3            /* Toss this char */
  100.  
  101. char prvchr, numone[6], numtwo[6], *numptr;
  102. int num1, num2, charflg=CF_OUTC;
  103.  
  104. Boolean use_ascii = true;    /* false means use graphics characters */
  105. Boolean keypad_app = false;    /* false means don't send escape sequences */
  106. extern Boolean interpret_control; /* false means show control character */
  107.  
  108. extern short sOut;    /* refnum of output port */
  109. typedef int (*PFI) ();
  110.  
  111. /* Terminal function declarations. */
  112.  
  113. int tab(), back_space(), carriage_return(), line_feed(), bell(), escape_seq(),
  114.     text_mode(), clear_line(), erase_display(), cursor_position(), cursor_up(),
  115.     cursor_down(), cursor_right(), cursor_left(), cursor_save(),
  116.     cursor_restore(), set_scroll_region(), reverse_line_feed(), dummy(),
  117.     delete_char(), insert_mode(), end_insert_mode(), insert_line(),
  118.     delete_line(), query_terminal(), multi_char(), toss_char(),
  119.     set_ascii(),set_graphics(),set_keypad(),reset_keypad(),cursor_attributes();
  120.  
  121. /* Terminal control character function command table. */
  122.  
  123. #define MINSINGCMDS 000
  124. #define MAXSINGCMDS 037
  125.  
  126. PFI controltable[MAXSINGCMDS-MINSINGCMDS+1] =
  127. {
  128.     dummy,                /*  0 */
  129.     dummy,                /*  1 */
  130.     dummy,                /*  2 */
  131.     dummy,                /*  3 */
  132.     dummy,                /*  4 */
  133.     dummy,                /*  5 */
  134.     dummy,                /*  6 */
  135.     bell,                /*  7 */
  136.     back_space,                /* 10 */
  137.     tab,                /* 11 */
  138.     line_feed,                /* 12 */
  139.     line_feed,                /* 13 (Vertical tab) */
  140.     line_feed,                /* 14 (Form feed) */
  141.     carriage_return,        /* 15 */
  142.     set_graphics,            /* 16 'N'*/
  143.     set_ascii,                /* 17 */
  144.     dummy,                /* 20 */
  145.     dummy,                /* 21 */
  146.     dummy,                /* 22 */
  147.     dummy,                /* 23 */
  148.     dummy,                /* 24 */
  149.     dummy,                /* 25 */
  150.     dummy,                /* 26 */
  151.     dummy,                /* 27 */
  152.     dummy,                /* 30 */
  153.     dummy,                /* 31 */
  154.     dummy,                /* 32 */
  155.     escape_seq,                /* 33 (Escape) */
  156.     dummy,                /* 34 */
  157.     dummy,                /* 35 */
  158.     dummy,                /* 36 */
  159.     dummy                /* 37 */
  160. };
  161.  
  162. #define MINSINGESCS 0040
  163. #define MAXSINGESCS 0137
  164.  
  165. PFI singescapetable[MAXSINGESCS-MINSINGESCS+1] =
  166. { 
  167.     dummy,                /*  40 */
  168.     dummy,                /*  41 */
  169.     dummy,                /*  42 */
  170.     toss_char,                /*  43 '#' */
  171.     dummy,                /*  44 */
  172.     dummy,                /*  45 */
  173.     dummy,                /*  46 */
  174.     dummy,                /*  47 */
  175.     toss_char,                /*  50 '(' */
  176.     toss_char,                /*  51 ')' */
  177.     dummy,                /*  52 */
  178.     dummy,                /*  53 */
  179.     dummy,                /*  54 */
  180.     dummy,                /*  55 */
  181.     dummy,                /*  56 */
  182.     dummy,                /*  57 */
  183.     set_graphics,            /*  60  '0' */
  184.     dummy,                /*  61 */
  185.     dummy,                /*  62 */
  186.     dummy,                /*  63 */
  187.     dummy,                /*  64 */
  188.     dummy,                /*  65 */
  189.     dummy,                /*  66 */
  190.     cursor_save,            /*  67 '7' */
  191.     cursor_restore,            /*  70 '8' */
  192.     dummy,                /*  71 */
  193.     dummy,                /*  72 */
  194.     dummy,                /*  73 */
  195.     dummy,                /*  74 '<' */
  196.     set_keypad,                /*  75 '=' */
  197.     reset_keypad,            /*  76 '>' */
  198.     dummy,                /*  77 */
  199.     dummy,                /* 100 */
  200.     dummy,                /* 101 */
  201.     set_ascii,                /* 102 'B' */
  202.     dummy,                /* 103 */
  203.     line_feed,                /* 104 'D' */
  204.     dummy,                /* 105 'E' */
  205.     dummy,                /* 106 */
  206.     dummy,                /* 107 */
  207.     dummy,                /* 110 */
  208.     dummy,                /* 111 */
  209.     dummy,                /* 112 */
  210.     dummy,                /* 113 */
  211.     dummy,                /* 114 */
  212.     reverse_line_feed,            /* 115 'M' */
  213.     dummy,                /* 116 */
  214.     dummy,                /* 117 */
  215.     dummy,                /* 120 */
  216.     dummy,                /* 121 */
  217.     dummy,                /* 122 */
  218.     dummy,                /* 123 */
  219.     dummy,                /* 124 */
  220.     dummy,                /* 125 */
  221.     dummy,                /* 126 */
  222.     dummy,                /* 127 */
  223.     dummy,                /* 130 */
  224.     dummy,                /* 131 */
  225.     query_terminal,            /* 132 'Z' */
  226.     multi_char,                /* 133 '[' */
  227.     dummy,                /* 134 */
  228.     dummy,                /* 135 */
  229.     dummy,                /* 136 */
  230.     dummy                /* 137 */
  231. };
  232.  
  233. /* Terminal escape sequence function command table */
  234.  
  235. #define MINMULTESCS 0100
  236. #define MAXMULTESCS 0177
  237.  
  238. PFI escapetable[MAXMULTESCS-MINMULTESCS+1] =
  239. {
  240.     dummy,                /* 100 */
  241.     cursor_up,                /* 101 'A' */
  242.     cursor_down,            /* 102 'B' */
  243.     cursor_right,            /* 103 'C' */
  244.     cursor_left,            /* 104 'D' */
  245.     dummy,                /* 105 */
  246.     dummy,                /* 106 */
  247.     dummy,                /* 107 */
  248.     cursor_position,            /* 110 'H' */
  249.     dummy,                /* 111 */
  250.     erase_display,            /* 112 'J' */
  251.     clear_line,                /* 113 'K' */
  252.     insert_line,            /* 114 'L' */
  253.     delete_line,            /* 115 'M' */
  254.     dummy,                /* 116 */
  255.     dummy,                /* 117 */
  256.     delete_char,            /* 120 'P' */
  257.     dummy,                /* 121 */
  258.     dummy,                /* 122 */
  259.     dummy,                /* 123 */
  260.     dummy,                /* 124 */
  261.     dummy,                /* 125 */
  262.     dummy,                /* 126 */
  263.     dummy,                /* 127 */
  264.     dummy,                /* 130 */
  265.     dummy,                /* 131 */
  266.     dummy,                /* 132 */
  267.     dummy,                /* 133 */
  268.     dummy,                /* 134 */
  269.     dummy,                /* 135 */
  270.     dummy,                /* 136 */
  271.     dummy,                /* 137 */
  272.     dummy,                /* 140 */
  273.     dummy,                /* 141 */
  274.     dummy,                /* 142 */
  275.     query_terminal,            /* 143 'c' */
  276.     dummy,                /* 144 */
  277.     dummy,                /* 145 */
  278.     cursor_position,            /* 146 'f' */
  279.     dummy,                /* 147 */
  280.     insert_mode,            /* 150 'h' */
  281.     dummy,                /* 151 */
  282.     dummy,                /* 152 */
  283.     dummy,                /* 153 */
  284.     end_insert_mode,            /* 154 'l' */
  285.     text_mode,                /* 155 'm' */
  286.     dummy,                /* 156 */
  287.     dummy,                /* 157 */
  288.     dummy,                /* 160 */
  289.     dummy,                /* 161 */
  290.     set_scroll_region,            /* 162 'r'*/
  291.     dummy,                /* 163 */
  292.     dummy,                /* 164 */
  293.     dummy,                /* 165 */
  294.     cursor_attributes,                /* 166 'v'*/
  295.     dummy,                /* 167 */
  296.     dummy,                /* 170 */
  297.     dummy,                /* 171 */
  298.     dummy,                /* 172 */
  299.     dummy,                /* 173 */
  300.     dummy,                /* 174 */
  301.     dummy,                /* 175 */
  302.     dummy,                /* 176 */
  303.     dummy                /* 177 */
  304. };
  305. /**********************************************************************/
  306. /*
  307.     The following routine returns true if pacing is turned on and
  308.     the last nonwhite character on the current line is the pacing character
  309. */
  310. Boolean OKToSendChar(theChar,pacing,refNum,inprog)
  311. char theChar;    /* the pacing character */
  312. Boolean pacing; /* true -> do pacing */
  313. short refNum;    /* channel for modem */
  314. Boolean *inprog; /* true means a line is being sent */
  315.  
  316. { short tmp; /* local index */
  317.   SerStaRec statRec;  /* for checking if we are xoff'ed */
  318.  
  319.     SerStatus(refNum,&statRec); /* check modem */
  320.     
  321.     if (statRec.xOffHold)  return false;  /* we are in a xoff state */
  322.     
  323.     if(!pacing) return true;  /* easy case */
  324.     
  325.     if (*inprog) return true; /* a CR will set inprog to false */
  326.     
  327.     for(tmp=0;tmp < curcol;tmp++) /* scan line looking for pace character */
  328.         if (scr[curlin][tmp] == theChar) {
  329.          *inprog = true;  /* starting a new line */
  330.          return true; /* gotit */
  331.         }
  332.     return false; /* nothing was on the line */
  333.     
  334.  }
  335.     
  336. /**********************************************************************/
  337.  
  338. static int strlen(s)
  339. char *s;
  340. { int i;
  341.   i=0;
  342.   while(*s++)i++;
  343.   return i;
  344.  }
  345. /* cursor stuff */
  346. /* for vertical cursor use this */
  347. void oldgetPenRect(r) /* returns address of rect to invert */
  348.   Rect *r;
  349.   { Point pt;  /* for pen cordinates */
  350.     GetPen(&pt);
  351.     r->top = pt.v - fontstuff.ascent;
  352.     r->left = /*(pt.h==LEFTMARGIN)?pt.h-1:*/ pt.h; /* offset one pixel */
  353.     r->bottom = pt.v +fontstuff.descent;
  354.     r->right  = /*(pt.h==LEFTMARGIN)?pt.h:*/ pt.h + 1;   /* skinny */
  355.    }
  356. void getPenRect(r)
  357.   Rect *r;
  358.  { Point pt;
  359.    GetPen(&pt);
  360.    r->top = useBlockCursor ? pt.v - fontstuff.ascent + 1: pt.v;
  361.    r->bottom = pt.v + fontstuff.descent;
  362.    r->left = pt.h;
  363.    r->right = pt.h + fontstuff.widMax ;
  364.   }
  365. void docursor()
  366.    { if(invisible) return;
  367.      if (!blink) return;
  368.      if (cursorActive)
  369.      if(cursorTime < tickCount )
  370.          { cursorTime += caretTime;
  371.             getPenRect(&penRect);
  372.             InvertRect(&penRect);
  373.             cursorInverted = !cursorInverted; /* change state */
  374.           }
  375.     }
  376.     
  377. void start_cursor()
  378.    { if(invisible) return;
  379.      cursorActive = True;
  380.      cursorTime = (tickCount) + (caretTime);
  381. /*     cursorInverted = false; */
  382.      if(!cursorInverted){
  383.      getPenRect(&penRect); InvertRect(&penRect);
  384.      cursorInverted =true;}
  385.     }
  386.     
  387. void stop_cursor()
  388.    { if (invisible) return;
  389.      cursorActive = False;
  390.      if (cursorInverted) {
  391.        getPenRect(&penRect); InvertRect(&penRect);
  392.        cursorInverted =false;
  393.        }
  394.     }
  395.     
  396. /**********************************************************************/
  397.  
  398. /* Connect support routines */
  399.  
  400. InitPage()
  401. {   short theNum;
  402.  
  403.     dumptr = (RgnHandle)NewRgn();
  404.     PenMode(patXor);
  405.     GetFNum("vt100",&theNum);
  406.     if(theNum)
  407.         TextFont(theNum);  /* keep it simple */
  408.     else TextFont(monaco);
  409.     TextSize(9);
  410.     GetFontInfo(&fontstuff);
  411.     init_term();            /* Set up some terminal variables */
  412.     clear_screen();            /* Clear the screen */
  413.     home_cursor();            /* Go to the upper left */
  414.     cursor_save();            /* Save this position */
  415.     cursorInverted = false;
  416.     start_cursor();
  417. }
  418.  
  419.  
  420.  
  421. /* writeps - write a pascal form string to the serial port.
  422.  *
  423.  */
  424.  
  425. writeps(s)
  426. char *s;
  427. {
  428.   long wcnt, w2;
  429.   int err; char *s2;
  430.  
  431.   w2 = wcnt = *s++;            /* get count */
  432.   err = FSWrite(sOut,&wcnt,s);    /* write the characters */
  433.   return;
  434. }
  435.  
  436. /* getindstr - given an indirect (or is it indexed) string and integer
  437.  *               n, return the pointer to the Nth substring.
  438.  *
  439.  * Indirect strings have the count of substrings in the first byte and
  440.  * each string follows with a length byte and a body.
  441.  *
  442.  * Substrings are referenced by 1..N
  443.  *
  444.  */
  445.  
  446. char *getindstr(indstr,n)
  447. char *indstr;
  448. {
  449.   register char *ip = indstr;
  450.   int i;
  451.  
  452.   if (n > *ip++)            /* too large? */
  453.    return("");                /* yes, return empty pascal string */
  454.  
  455.   for (i=1; i < n; i++)            /* scan until we hit the Nth */
  456.    ip += (*ip)+1;            /* move to next substring */
  457.  
  458.   return(ip);                /* return ptr to it */
  459. }
  460.  
  461.  
  462. char outbuf[MAXCOL+1];
  463. int outcnt=0, outcol;
  464.  
  465. flushbuf()
  466. {
  467.     Rect r;
  468.     Boolean cursorWasActive;
  469.  
  470.     if (outcnt == 0) return;        /* Nothing to flush */
  471.     
  472.     if(cursorWasActive = cursorActive) stop_cursor();
  473.  
  474. /* Erase a hole large enough for outcnt chars */
  475.  
  476.     makerect(&r,abslin,outcol,1,outcnt);
  477.  
  478.     if (Invert) FillRect(&r,qd.black);
  479.     else EraseRect(&r);
  480.  
  481.     outbuf[outcnt] = '\0';        /* Terminate the string */
  482.     DrawString(outbuf);            /* Output the string */
  483.     if(cursorWasActive)start_cursor();
  484.     outcnt = 0;                /* Say no more chars to output */
  485. }
  486.  
  487. buf_char(c)
  488. char c;
  489. {
  490.     if (outcnt == 0) outcol = curcol;    /* No chars in buffer, init column */
  491.     if(outcnt == MAXCOL){ SysBeep(3); return; } /* don't overflow buffer */
  492.     outbuf[outcnt++] = c;        /* Put in the buffer to output later */
  493. }
  494.  
  495. /*
  496.  *  put_ch:
  497.  *    Draws character and updates buffer
  498.  */
  499.     
  500. void Put_Char(c)
  501. char c;
  502. {
  503.     PFI funp, lookup();
  504.  
  505.     c &= 0177;
  506.     stop_cursor();
  507.     switch (charflg)
  508.     {
  509.     case CF_OUTC:            /* Just output the char */
  510.         drawAChar(c);
  511.         break;
  512.  
  513.     case CF_SESC:            /* In a single char escape seq */
  514.         if(c == '(') break;    /* wait for '0' or 'B' */
  515.         charflg = CF_OUTC;        /* Reset flag to simple outputting */
  516.         if(funp=lookup(c,singescapetable,MINSINGESCS,MAXSINGESCS))
  517.             (*funp)();        /* Do escape sequence function */
  518.         break;
  519.  
  520.     case CF_MESC:            /* Multichar escape sequence */
  521.         if (c >= 0x20 && c < 0x40)  /* Deal with the modifiers */
  522.         {
  523.         if (c >= '<' && c <= '?') prvchr = c;   /* Handle priv char */
  524.         else if ((c >= '0' && c <= '9') || c == '-' || c == '+')
  525.         {
  526.             *numptr++ = c;    /* Add the char to the num */
  527.             *numptr = '\0';    /* Terminate the string */
  528.         }
  529.         else if (c == ';') numptr = numtwo;    /* Go to next number */
  530.         }
  531.         else            /* End of sequence */
  532.         {
  533.         if (funp=lookup(c,escapetable,MINMULTESCS,MAXMULTESCS))
  534.         {
  535.             StringToNum(numone,&num1); /* Translate the numbers */
  536.             StringToNum(numtwo,&num2);
  537.             (*funp)();        /* Do the escape sequence function */
  538.         }
  539.         charflg = CF_OUTC;    /* Back to simple outputting */
  540.         }
  541.         break;
  542.  
  543.     case CF_TOSS:            /* Ignore this char */
  544.         charflg = CF_OUTC;        /* Reset flag */
  545.         break;
  546.     }
  547.     start_cursor();
  548. }
  549.  
  550. /*
  551.  * Routine makerect
  552.  *
  553.  * Make a rectangle in r starting on line lin and column col extending
  554.  * numlin lines and numcol characters.
  555.  *
  556.  */
  557.  
  558. makerect(r,lin,col,numlin,numcol)
  559. Rect *r;
  560. int lin, col, numlin, numcol;
  561. {
  562.     r->top = lin * LINEHEIGHT + TOPMARGIN;
  563.     r->left = col * CHARWIDTH + LEFTMARGIN;
  564.     r->bottom = r->top + numlin * LINEHEIGHT;
  565.     r->right = r->left + numcol * CHARWIDTH;
  566. }
  567.  
  568. /*
  569.  *   Lookup:
  570.  *    Lookup a given character in the apropriate character table, and
  571.  *    return a pointer to the appropriate function, if it exists.
  572.  */
  573.  
  574. PFI
  575. lookup(index,table,min,max)
  576. char index;
  577. PFI table[];
  578. int min, max;
  579. {
  580.     if (index > max || index < min)
  581.         return((PFI) NULL);            /* Don't index out of range */
  582.     return(table[index-min]);
  583. }
  584.  
  585.  
  586. /*
  587.  *   Flushio:
  588.  *    Initialize some communications constants, and clear screen and
  589.  *    character buffers.
  590.  */
  591.  
  592. flushio()
  593. {
  594. }    
  595.  
  596.    
  597. /* sendbreak - sends a break across the communictions line.
  598.  *
  599.  * The argument is in units of approximately 0.05 seconds (or 50
  600.  * milliseconds).  To send a break of duration 250 milliseconds the
  601.  * argument would be 5; a break of duration 3.5 seconds would be (umm,
  602.  * lets see now) 70.
  603.  *
  604.  */
  605.  
  606. sendbreak(msunit)
  607. { 
  608.     int finalticks;
  609.  
  610.  
  611. }
  612.      
  613. drawAChar(chr)
  614. unsigned char chr;
  615. {
  616.     PFI funp;
  617.     Boolean cursorWasActive;
  618.  
  619.     if(cursorWasActive = cursorActive)stop_cursor();
  620.     
  621. /* If it's a control char, do the apropriate function. */
  622.     if ((chr < (unsigned char)' ') && interpret_control)        /* Is it a control character */
  623.     {     
  624.     flushbuf();
  625.     if (funp=lookup(chr,controltable,MINSINGCMDS,MAXSINGCMDS)) (*funp)();
  626.     }
  627.     else if (chr < (unsigned char)0177)              /* Handle graphic characters */
  628.     {
  629.     if(!use_ascii)
  630.       if((chr >= (unsigned char)0137) && (chr <= (unsigned char)0176)) /* if in graphics mode */
  631.          chr += 0200;            /* offset to high ascii */
  632.          
  633.      if (chr < (unsigned char)0040)            /* if a control char */
  634.         if(!interpret_control) chr += 0200;
  635.         
  636.     if (curcol >= MAXCOL)        /* Are we about to wrap around? */
  637.     {
  638.         if (autowrap)        /* If autowrap indicated wrap */
  639.         {
  640.         flushbuf();
  641.         carriage_return();
  642.         line_feed();
  643.         }
  644.         else
  645.         {
  646.         back_space();        /* Otherwise just overwrite */
  647.         outcnt--;        /* Overwrite buffered chars too */
  648.         }
  649.     }
  650.     if (insert)            /* Insert mode? */
  651.     {
  652.         insert_char();        /* Open hole for char if requested */
  653.         erase_char();        /* Erase the old char */
  654.         DrawChar(chr);
  655.     }
  656.     else buf_char(chr);        /* Otherwise just buffer the char */
  657.     scr[curlin][curcol++] = chr;
  658.     }
  659.   if(cursorWasActive)start_cursor();
  660. }    
  661.  
  662. void drawCString(strptr)
  663.      char * strptr;
  664.      { char ch;
  665.        while(ch=*strptr++)drawAChar(ch);
  666.       }
  667.  
  668. void drawPString(strptr)
  669.      char *strptr;
  670.      { short i;
  671.        for(i=1;i<=strptr[0];i++)drawAChar(strptr[i]);
  672.       }
  673.       
  674.  
  675. /*
  676.  *    Control character functions:
  677.  *        Each of the following allow the mac to simulate
  678.  *        the behavior of a terminal when given the proper
  679.  *        control character.
  680.  */
  681.  
  682. back_space()
  683. {
  684.     if (curcol > 0) relmove(-1,0);
  685. }
  686.  
  687. erase_char()
  688. {
  689.     Rect r;
  690.  
  691.     scr[curlin][curcol] = ' ';        /* Erase char for update */
  692.     makerect(&r,abslin,curcol,1,1);    /* One char by one line */
  693.  
  694.     if (Invert) FillRect(&r,qd.black);
  695.     else EraseRect(&r);
  696. }
  697.  
  698. tab()
  699. {
  700.     int i;
  701.  
  702.     for (i=0; i<NUMTABS; i++)
  703.     {
  704.         if (tabstops[i] > curcol)
  705.     {
  706.         absmove(tabstops[i],abslin);
  707.         return;
  708.     }
  709.     }
  710. }
  711.  
  712. line_feed()
  713. {
  714.     int tbot, ttop, tlout;
  715.  
  716.     if (curlin == scrbot)
  717.     {
  718.     ScrollRect((Rect *) scrollrect,0,-LINEHEIGHT,dumptr);
  719.     SetEmptyRgn(dumptr);
  720.     zeroline(scrtop);
  721.     tbot = scrbot;
  722.     ttop = scrtop;
  723.     tlout = nxtlin[scrbot];
  724.     nxtlin[scrbot] = scrtop;
  725.     scrbot = scrtop;
  726.     scrtop = nxtlin[scrtop];
  727.     if (ttop == toplin) toplin = scrtop;
  728.         else nxtlin[fndprv(ttop)] = scrtop;
  729.     if (tbot == botlin)
  730.     {
  731.         botlin = scrbot;
  732.         nxtlin[botlin] = -1;
  733.     }
  734.     else nxtlin[scrbot] = tlout;
  735.     curlin = scrbot;
  736.     }
  737.     else relmove(0,1);
  738. }
  739.  
  740. reverse_line_feed()
  741. {
  742.     int tbot, ttop, tlout;
  743.  
  744.     if (curlin == scrtop)
  745.     {
  746.     ScrollRect((Rect *) scrollrect,0,LINEHEIGHT,dumptr);
  747.     SetEmptyRgn(dumptr);
  748.     zeroline(scrbot);
  749.     tbot = scrbot;
  750.     ttop = scrtop;
  751.     tlout = nxtlin[scrbot];
  752.     nxtlin[scrbot] = scrtop;
  753.     scrtop = scrbot;
  754.     scrbot = fndprv(scrbot);
  755.     if (ttop == toplin) toplin = scrtop;
  756.         else nxtlin[fndprv(ttop)] = scrtop;
  757.     if (tbot == botlin)
  758.     {
  759.         botlin = scrbot;
  760.         nxtlin[botlin] = -1;
  761.     }
  762.     else nxtlin[scrbot] = tlout;
  763.     curlin = scrtop;
  764.     }
  765.     else relmove(0,-1);
  766. }
  767.  
  768. carriage_return()
  769. {
  770.     absmove(0,abslin);
  771. }
  772.  
  773. clear_screen()
  774. {
  775.     register int i;
  776.     Rect r;
  777.     GrafPtr thisPortptr;
  778.  
  779. /*
  780.     makerect(&r,0,0,MAXLIN,MAXCOL);    
  781.     EraseRect(&r);
  782. */
  783.     GetPort(&thisPortptr);
  784.     EraseRect(&thisPortptr->portRect);
  785.     
  786.     for (i=0; i<MAXLIN; i++) zeroline(i);   /* Clear up the update records */
  787. }
  788.  
  789. home_cursor()
  790. {
  791.     absmove(0,0);
  792. }
  793.  
  794. bell()
  795. {
  796.     SysBeep(3);
  797. }
  798.  
  799. escape_seq()
  800. {
  801.     charflg = CF_SESC;            /* Say we are in an escape sequence */
  802. }
  803.  
  804. clear_line()
  805. {
  806.     int i;
  807.     Rect r;
  808.  
  809.     switch (num1)
  810.     {
  811.     case 0:                /* Clear:  here to the right */
  812.         makerect(&r,abslin,curcol,1,MAXCOL-curcol);
  813.         for (i=curcol; i<MAXCOL; i++) scr[curlin][i] = ' ';
  814.         break;
  815.  
  816.     case 1:                /* Clear:  left to here */
  817.         makerect(&r,abslin,0,1,curcol+1);
  818.         for (i=0; i<=curcol; i++) scr[curlin][i] = ' ';
  819.         break;
  820.  
  821.     case 2:                /* Clear:  entire line */
  822.         makerect(&r,abslin,0,1,MAXCOL);
  823.         zeroline(curlin);
  824.         break;
  825.     }
  826.     EraseRect(&r);
  827. }
  828.  
  829. erase_display()
  830. {
  831.     int i;
  832.     Rect r;
  833.  
  834.     switch (num1)
  835.     {
  836.     case 0:
  837.         clear_line();        /* Same num1 causes correct clear */
  838.         makerect(&r,abslin+1,0,MAXLIN-abslin,MAXCOL);
  839.         EraseRect(&r);
  840.         for (i=abslin+1; i<MAXLIN; i++) zeroline(fndrel(i));
  841.         break;
  842.  
  843.     case 1:
  844.         clear_line();        /* Same num1 causes correct clear */
  845.         makerect(&r,0,0,abslin,MAXCOL);
  846.         EraseRect(&r);
  847.         for (i=0; i<abslin; i++) zeroline(fndrel(i));
  848.         break;
  849.  
  850.     case 2:
  851.         clear_screen();
  852.         break;
  853.     }
  854. }
  855.             
  856. /**** All cursor moves need to check that they don't go beyond the margins */
  857.  
  858. cursor_right()
  859. {
  860.     if (num1 == 0) num1 = 1;
  861.     relmove(num1,0);
  862. }
  863.  
  864. cursor_left()
  865. {
  866.     if (num1 == 0) num1 = 1;
  867.     relmove(-num1,0);
  868. }
  869.  
  870. cursor_up()
  871. {
  872.     if (num1 == 0) num1 = 1;
  873.     relmove(0,-num1);
  874. }
  875.  
  876. cursor_down()
  877. {
  878.     if (num1 == 0) num1 = 1;
  879.     relmove(0,num1);
  880. }
  881.  
  882. cursor_position()
  883. {
  884.     if (--num1 < 0) num1 = 0;
  885.     if (--num2 < 0) num2 = 0;
  886.  
  887.     absmove(num2,num1);
  888. }
  889.  
  890. cursor_save()
  891. {
  892.     savcol = curcol;            /* Save the current line and column */
  893.     savlin = abslin;
  894. }
  895.  
  896. cursor_restore()
  897. {
  898.     absmove(savcol,savlin);        /* Move to the old cursor position */
  899. }
  900.  
  901. cursor_draw()
  902. {
  903.     Line(CHARWIDTH,0);            /* Draw cursor */
  904. }
  905.  
  906. cursor_erase()
  907. {
  908.     Line(-CHARWIDTH,0);            /* Erase cursor */
  909. }
  910.  
  911. set_scroll_region()
  912. {
  913.     if (--num1 < 0) num1 = 0;        /* Make top of line (prev line) */
  914.     if (num2 == 0) num2 = 24;        /* Zero means entire screen */
  915.  
  916.     topmargin = scrollrect[0] = (num1 * LINEHEIGHT) + TOPMARGIN;
  917.     bottommargin = scrollrect[2] = (num2 * LINEHEIGHT) + TOPMARGIN;
  918.  
  919.     scrtop = fndrel(num1);
  920.     scrbot = fndrel(num2-1);
  921.  
  922.     home_cursor();            /* We're supposed to home it! */
  923. }
  924.  
  925.  
  926. text_mode()                /**** */
  927. {
  928.     switch(num1)
  929.     {
  930.     case 0: 
  931.         Invert=FALSE;
  932.         textstyle=0;
  933.         TextFace(0);
  934.         TextMode(srcOr);
  935.         TextSize(9);
  936.         break;
  937.  
  938.     case 1:
  939.         textstyle +=bold;
  940.         TextFace(textstyle);
  941.         TextSize(8);    /* shrink a little */
  942.         break;
  943.  
  944.     case 4:
  945.         textstyle+=underline;
  946.         TextFace(textstyle);
  947.         TextSize(9);
  948.         break;
  949.  
  950.     case 7:
  951.         Invert=TRUE;
  952.         TextMode(srcBic);
  953.         TextSize(9);
  954.         break;
  955.  
  956.     case 22:
  957.         if (textstyle >= bold)
  958.         {
  959.         TextFace(textstyle-bold);
  960.         textstyle -= bold;
  961.         }
  962.         break;
  963.  
  964.     case 24:
  965.         if (textstyle >= underline)
  966.         {
  967.         TextFace(textstyle-underline);
  968.         textstyle -= underline;
  969.         }
  970.         break;
  971.  
  972.     case 27:
  973.         Invert = FALSE;
  974.         TextMode(srcOr);
  975.         break;
  976.     }
  977. }    
  978.  
  979. /**** NYI */
  980. insert_line()
  981. {
  982.     Rect r;
  983.  
  984.     if (num1 == 0) num1 = 1;
  985.  
  986.     makerect(&r,abslin,0,0,MAXCOL);
  987.     r.bottom = bottommargin;        /* Just do this for now */
  988.  
  989.     if (num1 > fndabs(scrbot) - abslin)
  990.         num1 = fndabs(scrbot) - abslin;
  991.  
  992.     ScrollRect(&r,0,num1*LINEHEIGHT,dumptr);
  993.     SetEmptyRgn(dumptr);
  994. /* Do the book keeping!!! */
  995. }
  996.  
  997. delete_line()
  998. {
  999.     Rect r;
  1000.  
  1001.     if (num1 == 0) num1 = 1;
  1002.  
  1003.     makerect(&r,abslin,0,0,MAXCOL);
  1004.     r.bottom = bottommargin;        /* Just do this for now */
  1005.  
  1006.     if (num1 > fndabs(scrbot) - abslin)
  1007.         num1 = fndabs(scrbot) - abslin;
  1008.  
  1009.     ScrollRect(&r,0,-num1*LINEHEIGHT,dumptr);
  1010.     SetEmptyRgn(dumptr);
  1011. /* Do the book keeping!!! */
  1012. }
  1013.  
  1014. delete_char()
  1015. {
  1016.     int i;
  1017.     Rect r;
  1018.  
  1019.     if (num1 == 0) num1 = 1;
  1020.  
  1021.     makerect(&r,abslin,curcol,1,MAXCOL-curcol);
  1022.  
  1023.     if(num1 > MAXCOL - curcol - 1) num1 = MAXCOL - curcol - 1;
  1024.  
  1025.     ScrollRect(&r,-CHARWIDTH*num1,0,dumptr);  /* Scroll em out */
  1026.     SetEmptyRgn(dumptr);
  1027.  
  1028. /* Shift em down */
  1029.  
  1030.     for (i=curcol; i<MAXCOL-num1; i++) scr[abslin][i] = scr[abslin][i+num1];
  1031.     while (i < MAXCOL) scr[abslin][i++] = ' ';    /* Fill in holes with spaces */
  1032. }
  1033.  
  1034. insert_char()
  1035. {
  1036.     int i;
  1037.     Rect r;
  1038.  
  1039.     makerect(&r,abslin,curcol,1,MAXCOL-curcol);
  1040.  
  1041.     ScrollRect(&r,CHARWIDTH,0,dumptr);
  1042.     SetEmptyRgn(dumptr);
  1043.  
  1044. /* Shift em up */
  1045.  
  1046.     for (i=MAXCOL-1; i>curcol+1; i--) scr[abslin][i-1] = scr[abslin][i];
  1047.     scr[abslin][curcol] = ' ';
  1048. }
  1049.  
  1050. insert_mode()
  1051. {
  1052.     if (prvchr == '?') return;        /* Don't deal with these calls */
  1053.     if (num1 == 4) insert = TRUE;
  1054. }
  1055.  
  1056. end_insert_mode()
  1057. {
  1058.     if (prvchr == '?') return;        /* Don't deal with these calls */
  1059.     if (num1 == 4) insert = FALSE;
  1060. }
  1061.  
  1062. query_terminal()
  1063. {
  1064.     long wrcnt, w2;
  1065.     int err; char *s2;
  1066.  
  1067.     w2 = wrcnt = strlen(querystring);    /* How long is the string? */
  1068.     err = FSWrite(sOut,&wrcnt,querystring);    /* Respond to the query */
  1069. }
  1070.  
  1071. dummy()
  1072. {
  1073. }
  1074.  
  1075. multi_char()
  1076. {
  1077.     numone[0] = numtwo[0] = '0';    /* Initialize the numbers to zero */
  1078.     numone[1] = numtwo[1] = '\0';
  1079.     numptr = numone;            /* Place to put the next number */
  1080.     prvchr = '\0';            /* No priv char yet */
  1081.     charflg = CF_MESC;            /* Say we are in a ESC [ swequence */
  1082. }
  1083.  
  1084. toss_char()
  1085. {
  1086.     charflg = CF_TOSS;
  1087. }
  1088.  
  1089. /*
  1090.  * Routine zeroline
  1091.  *
  1092.  * Zero (set to space) all the characters in relative line lin.
  1093.  *
  1094.  */
  1095.  
  1096. zeroline(lin)
  1097. int lin;
  1098. {
  1099.     register int i;
  1100.  
  1101.     for (i=0; i<MAXCOL; i++) scr[lin][i] = ' ';
  1102. }
  1103.  
  1104. /*
  1105.  * Move a relative number of lines and chars.  Both can be negative.
  1106.  *
  1107.  */
  1108.  
  1109. relmove(hor,ver)
  1110. {
  1111.     Move(hor*CHARWIDTH,ver*LINEHEIGHT);
  1112.     curcol += hor;
  1113.     abslin += ver;
  1114.     curlin = fndrel(abslin);
  1115. }
  1116.  
  1117. /*
  1118.  * Move to absolute position hor char and ver line.
  1119.  *
  1120.  */
  1121.  
  1122. absmove(hor,ver)
  1123. {
  1124.     MoveTo(hor*CHARWIDTH+LEFTMARGIN,(ver+1)*LINEHEIGHT+TOPMARGIN-LINEADJ);
  1125.     curcol = hor;
  1126.     abslin = ver;
  1127.     curlin = fndrel(ver);
  1128. }
  1129.  
  1130. /*
  1131.  * Find the relative line number given the absolute one.
  1132.  *
  1133.  */
  1134.  
  1135. fndrel(linum)
  1136. int linum;
  1137. {
  1138.     register int i, lin;
  1139.  
  1140.     lin = toplin;
  1141.     for (i=0; i<linum; i++) lin = nxtlin[lin];
  1142.     return(lin);
  1143. }
  1144.  
  1145. /*
  1146.  * Find the absolute line number given the relative one.
  1147.  *
  1148.  */
  1149.  
  1150. fndabs(linum)
  1151. int linum;
  1152. {
  1153.     int i, lin;
  1154.  
  1155.     lin = toplin;
  1156.     i = 0;
  1157.     while (lin != linum)
  1158.     {
  1159.     i++;
  1160.     lin = nxtlin[lin];
  1161.     }
  1162.     return(i);
  1163. }
  1164.  
  1165. /*
  1166.  * Find the previous relative line number from relative line linum.
  1167.  *
  1168.  */
  1169.  
  1170. fndprv(linum)
  1171. int linum;
  1172. {
  1173.     int lin;
  1174.  
  1175.     lin = toplin;
  1176.     while (nxtlin[lin] != linum) lin = nxtlin[lin];
  1177.     return(lin);
  1178. }
  1179.  
  1180. term_redraw()
  1181. {
  1182.     int i, lin;
  1183.  
  1184.     lin = toplin;
  1185.     for (i=0; i<MAXLIN; i++)
  1186.     {
  1187.     MoveTo(LEFTMARGIN,(i+1)*LINEHEIGHT+TOPMARGIN-LINEADJ);
  1188.     DrawString(scr[lin]);
  1189.     lin = nxtlin[lin];
  1190.     }
  1191.     MoveTo(curcol*CHARWIDTH+LEFTMARGIN,
  1192.         (abslin+1)*LINEHEIGHT+TOPMARGIN-LINEADJ);
  1193. }
  1194.  
  1195. init_term()
  1196. {
  1197.     int i;
  1198.  
  1199.     for (i=0; i<MAXLIN; i++)
  1200.     {
  1201.     nxtlin[i] = i + 1;        /* Tie together the linked list */
  1202.     scr[i][MAXCOL] = '\0';        /* Terminate the lines as strings */
  1203.     }
  1204.     toplin = 0;                /* Initialize the top and bottom ptr */
  1205.     botlin = MAXLIN - 1;
  1206.     scrtop = toplin;            /* Scrolling region equals all */
  1207.     scrbot = botlin;
  1208.     nxtlin[botlin] = -1;        /* Indicate this is the end */
  1209. }
  1210.  
  1211. reset_term()
  1212. {
  1213.     stop_cursor();            /* take cursor off */
  1214.     clear_screen();
  1215.     home_cursor();
  1216.     cursor_save();
  1217.     
  1218.     Invert=FALSE;
  1219.     textstyle=0;
  1220.     TextFace(0);
  1221.     TextMode(srcOr);
  1222.     TextSize(9);
  1223.     
  1224.     use_ascii = true;    /* false means use graphics characters */
  1225.     keypad_app = false;    /* false means don't send escape sequences */
  1226.     init_term();
  1227.     start_cursor();
  1228.     SysBeep(10);
  1229.  }
  1230. /* 
  1231.  *    Support for different cursor attributes
  1232.  */
  1233. cursor_attributes()
  1234. { stop_cursor();
  1235.   switch(num1){
  1236.   case 0: invisible =false;
  1237.             break;
  1238.   case 1: invisible = true;
  1239.               break;
  1240.   case 2: useBlockCursor = false;  /* use underline */
  1241.               break;
  1242.   case 3: useBlockCursor = true;        /* use block */
  1243.               break;
  1244.   case 4: blink = false;    /* don't blink */
  1245.               break;
  1246.   case 5: blink = true;
  1247.               break;
  1248.  }
  1249.  start_cursor();
  1250.  }
  1251. /*
  1252.     Support for change keypad mode and alternate character set
  1253. */
  1254.  
  1255. set_ascii()
  1256. { use_ascii = true;}
  1257.  
  1258. set_graphics()
  1259.  { use_ascii = false; }
  1260.  
  1261. set_keypad()
  1262.   { keypad_app = true; }
  1263.   
  1264. reset_keypad()
  1265.    { keypad_app = false; }